package com.yidu.service.impl;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.yidu.comment.Tools;
import com.yidu.dao.SnAuditMapper;
import com.yidu.dao.SnComInDetailMapper;
import com.yidu.dao.SnComInventoryMapper;
import com.yidu.dao.SnComPurDetailMapper;
import com.yidu.dao.SnComPurchaseMapper;
import com.yidu.dao.SnComSaDetailMapper;
import com.yidu.dao.SnComSalesMapper;
import com.yidu.dao.SnCommodityMapper;
import com.yidu.model.SnAudit;
import com.yidu.model.SnComInDetail;
import com.yidu.model.SnComInventory;
import com.yidu.model.SnComPurDetail;
import com.yidu.model.SnComPurchase;
import com.yidu.model.SnComSaDetail;
import com.yidu.model.SnComSales;
import com.yidu.model.SnComType;
import com.yidu.model.SnCommodity;
import com.yidu.model.SnUser;
import com.yidu.service.SnComPurchaseService;

@Service
public class SnComPurchaseServiceImpl implements SnComPurchaseService{
	/**
	 * 注入库存表
	 */
	@Resource
	SnComInventoryMapper scim;
	/**
	 * 注入商品表
	 */
	@Resource
	SnCommodityMapper scm;
	/**
	 * 注入采购表
	 */
	@Resource
	SnComPurchaseMapper scpm;
	/**
	 * 注入采购详情
	 */
	@Resource
	SnComPurDetailMapper scpdm;
	/**
	 * 注入审核表
	 */
	@Resource
	SnAuditMapper sam;
	/**
	 * 注入库存详情表
	 */
	@Resource
	SnComInDetailMapper scidm;
	/**
	 * 注入退货表
	 */
	@Resource
	SnComSalesMapper scsm;
	/**
	 * 注入退货详情表
	 */
	@Resource
	SnComSaDetailMapper scsdm;
	
	/**
	 * 采购表分页查询
	 */
	@Override
	public List<SnComPurchase> findAll(Map<String, Object> map) {
		List<SnComPurchase> list = scpm.findAll(map);
		return list;
	}

	/**
	 * 查询采购表的行数
	 */
	@Override
	public int findCount(Map<String, Object> map) {
		return scpm.findCount(map);
	}

	/**
	 * 查询商品表
	 */
	@Override
	public List<SnCommodity> findAllCommodity(Map<String, Object> map1) {
		return scpm.findAllCommodity(map1);
	}

	/**
	 * 查询商品表行数
	 */
	@Override
	public int findCommodityCount(Map<String, Object> map1) {
		return scpm.findCommodityCount(map1);
	}

	/**
	 * 查询商品类型
	 */
	@Override
	public List<SnComType> findAllSnComType() {
		return scpm.findAllSnComType();
	}

	/**
	 * 增加采购和采购详情表
	 */
	@Override
	public int insert(String tianJia,SnUser user) {
		//定义一个id为常量a接收
		String a = Tools.getDateOrderNo();
		//得到详情表的对象
		SnComPurDetail scpd = new SnComPurDetail();
		//总金额
		double sun=0;
		//总数量
		int count=0;
		//把传过来的字符串按#拆分
		String[] com = tianJia.split("#");
		//遍历com数组
		for(int i=0;i<com.length;i++) {
			//把循环的数组按 , 拆分 
			String[] com2 = com[i].split(",");
			//把数组的第七下标循环把数量加起来赋给总数量
			count += Integer.valueOf(com2[7]);
			//把数组的第八下标循环把金额加起来赋给总金额
			sun += Double.valueOf(com2[8]);
		}
		
		//获取采购表对象
		SnComPurchase scp = new SnComPurchase();
		scp.setPurId(a); 							    			//增加采购表id
		scp.setBraId(user.getBraId());								//分公司
		scp.setPurSum(new BigDecimal(sun)); 						//采购总金额
		scp.setPurState(0); 										//采购状态 0
		scp.setIsva(0); 											//是否有效 0
		scp.setOptime(Tools.getTimeStr(new Date())); 				//采购时间
		scp.setOper(user.getUserId()); 								//采购人
		scp.setPurCount(count); 									//采购总数量
		scp.setSort(1); 											//排序 1
		//增加采购表
		int rows = scpm.insertSelective(scp);
		//定义一个变量 ，接受采购详情表增加返回的值
		int rows2 = 0;
		//把传过来的字符串按#拆分
		String[] com11 = tianJia.split("#");
		//遍历com11数组
		for(int i=0;i<com11.length;i++) {
			//把循环的数组按 , 拆分
			String[] com22 = com11[i].split(",");
			
			//采购详情赋值
			scpd.setPdId(Tools.getDateOrderNo());
			//采购表id
			scpd.setPurId(a);
			//下标为0的商品赋值
			scpd.setComId(com22[0]);
			//下标为7的数量赋值
			scpd.setPdNumber(Integer.valueOf(com22[7]));
			//下标为3商品价格
			scpd.setPdMoney(new BigDecimal(com22[3]));
			//下标为8小计赋值
			scpd.setPdSum(new BigDecimal(com22[8]));
			//isva属性赋值
			scpd.setIsva(1);
			//时间
			scpd.setOptime(Tools.getTimeStr(new Date()));
			//排序
			scpd.setSort(Integer.valueOf(Tools.getTimeStamp()));
			//增加采购详情表
			rows2 = scpdm.insertSelective(scpd);
		}
		if(rows>0 && rows2>0) {
			return 1;
		}else {
			return 0;
		}
	}

	/**
	 * 增加审核表
	 */
	@Override
	public int insertSnAudit(String purId,String auIdea,SnUser user) {
		//得到审核对象
		SnAudit sa = new SnAudit();
		//审核id
		sa.setAuId(Tools.getDateOrderNo());
		//业务id
		sa.setAllId(purId);
		//审核时间
		sa.setOptime(Tools.getTimeStr(new Date()));
		//审核人
		sa.setOper(user.getUserName());
		//审核状态1
		sa.setAuState(1);
		//审核意见
		sa.setAuIdea(auIdea);
		//审核部门  (采购提交审核)
		sa.setAuComment("采购提交审核");
		//增加审核表
		int rows = sam.insertSelective(sa);
		//得到采购审核表对象
		SnComPurchase scp = new SnComPurchase();
		//采购id
		scp.setPurId(purId);
		//修改isva状态1
		scp.setIsva(1);
		//排序1
		scp.setSort(1);
		//修改采购表状态
		scpm.updateByPrimaryKeySelective(scp);
		
		if(rows>0) {
			return 1;
		}else {
			return 0;
		}
	}

	/**
	 * 采购删除      删除采购和采购详情表
	 */
	@Override
	public int delete(String purId) {
		//根据采购id删除采购详情表
		int rows2 = scpdm.delete(purId);
		//根据id删除采购详情表
		int rows = scpm.deleteByPrimaryKey(purId);
		
		if(rows>0 && rows2>0) {
			return 1;
		}else {
			return 0;
		}
	}

	/**
	 * 根据商品id查询商品表
	 */
	@Override
	public SnCommodity findById(String comId) {
		return scm.selectByPrimaryKey(comId);
	}
	
	/**
	 * 根据商品id查询商品表
	 */
	@Override
	public List<SnComPurchase> findDetailById(String purId) {
		return scpdm.findDetailById(purId);
	}

	/**
	 * 修改编辑
	 */
	@Override
	public int update(String tianJia, String purId, SnUser user) {
		//根据采购id删除采购详情表
		int rows2 = scpdm.delete(purId);
		//得到详情表的对象
		SnComPurDetail scpd = new SnComPurDetail();
		//总金额
		double sun=0;
		//总数量
		int count=0;
		//把传过来的字符串按#拆分
		String[] com = tianJia.split("#");
		//遍历com数组
		for(int i=0;i<com.length;i++) {
			//把循环的数组按 , 拆分
			String[] com2 = com[i].split(",");
			//循环把数组下标7数量加起来
			count += Integer.valueOf(com2[7]);
			//循环把数组下标8金额加起来
			sun += Double.valueOf(com2[8]);
		}
		
		//获取采购表对象
		SnComPurchase scp = new SnComPurchase();
		scp.setPurId(purId); 							    //增加采购表id
		scp.setBraId(user.getBraId());						//分公司
		scp.setPurSum(new BigDecimal(sun)); 				//采购总金额
		scp.setPurState(0); 								//采购状态0
		scp.setIsva(0); 									//是否有效0
		scp.setOptime(Tools.getTimeStr(new Date())); 		//采购时间
		scp.setOper(user.getUserId()); 						//采购人
		scp.setPurCount(count); 							//采购总数量
		scp.setSort(1); 									//排序1
		//修改采购表
		int rows3 = scpm.updateByPrimaryKeySelective(scp);
		//定义一个变量，接受采购详情表增加返回的值
		int rows4 = 0;
		//把传过来的字符串按#拆分
		String[] com11 = tianJia.split("#");
		//遍历com11数组
		for(int i=0;i<com11.length;i++) {
			//把循环的数组按 , 拆分
			String[] com22 = com11[i].split(",");
			//采购详情赋值
			scpd.setPdId(Tools.getDateOrderNo());
			//采购表id
			scpd.setPurId(purId);
			//商品赋值
			scpd.setComId(com22[0]);
			//下标为7 数量赋值
			scpd.setPdNumber(Integer.valueOf(com22[7]));
			//下标为3  商品价格
			scpd.setPdMoney(new BigDecimal(com22[3]));
			//下标为8 小计赋值
			scpd.setPdSum(new BigDecimal(com22[8]));
			//增加采购详情表
			rows4 = scpdm.insertSelective(scpd);
		}
		if(rows2>0 && rows3>0 && rows4>0) {
			return 1;
		}else {
			return 0;
		}
		
	}

	/**
	 * 根据id查询审核表
	 */
	@Override
	public List<SnAudit> snaudit(Map<String, Object> map1) {
		return sam.snaudit(map1);
	}

	/**
	 * 入库
	 */
	@Override
	public int ruku(String purId,String braId, SnUser user) {
		//通过采购id查询采购详情表																		fdb
		List<SnComPurDetail> list = scpdm.findDetailBypurId(purId);
		//定义变量接收 增加分公司库存详情表
		int rows6 = 0;
		//遍历采购详情表
		for (SnComPurDetail snComPurDetail : list) {
			//得到库存的对象
			SnComInventory sci = new SnComInventory();
			//得到商品数量并赋值给库存数量
			sci.setCiNumber(BigDecimal.valueOf(snComPurDetail.getPdNumber()));
			//得到商品id并赋值给库存商品id
			sci.setComId(snComPurDetail.getComId());
			//直接定义公司id
			sci.setBraId(braId);
			//通过分公司id和商品id查询是否用库存																fc
			SnComInventory sci2 = scpdm.findCent(sci);
			//库存为空
			if(sci2==null) {
				//isva赋值1
				sci.setIsva(1);
				//时间赋值
				sci.setOptime(Tools.getTimeStr(new Date()));
				//姓名赋值
				sci.setOper(user.getUserName());
				//排序赋值
				sci.setSort(Integer.valueOf(Tools.getTimeStamp()));
				//商品仓库id
				sci.setCiId(Tools.getDateOrderNo());
				//采购商品对象																			fbu
				SnComPurchase scp = scpm.findByUnit(sci);
				//仓库商品单位赋值
				sci.setCiUnit(scp.getDanwei());
				//仓库成本价赋值
				sci.setCiCost(scp.getCbejia());
				//仓库销售价赋值
				sci.setCiSales(scp.getCshjia());
				//增加库存表
				scim.insertSelective(sci);
			}else {
				//修改分公司库存数量
				scpdm.updateCent(sci);
			}
			//通过分公司id和商品id查询是否用库存	
			SnComInventory sci3 = scpdm.findCent(sci);
			//得到库存详情对象
			SnComInDetail scd = new SnComInDetail();
			//详情表id
			scd.setCidId(Tools.getDateOrderNo());
			//库存表id
			scd.setCiId(sci3.getCiId());
			//根据商品id查询商品表中的名称																	fbia
			SnCommodity sc = scpm.findByIdAll(snComPurDetail.getComId());
			//库存记录说明
			scd.setCidExplain("公司采购"+sc.getComName()+"共"+snComPurDetail.getPdNumber()+"件");
			//是否有效1
			scd.setIsva(1);
			//时间
			scd.setOptime(Tools.getTimeStr(new Date()));
			//库存详情操作人
			scd.setOper(user.getUserId());
			//通过商品库存id增加分公司库存详情表
			rows6 = scidm.insertSelective(scd);
		}
		
		//得到采购审核表对象
		SnComPurchase scp = new SnComPurchase();
		//采购表id
		scp.setPurId(purId);
		//采购表状态
		scp.setIsva(20);
		//修改采购表状态
		int rows5 = scpm.updateByPrimaryKeySelective(scp);
		
		if(rows5>0 && rows6>0) {
			return 1;
		}else {
			return 0;
		}
	}

	

	/**
	 * 点击退货提交(陈思托)
	 */
	@Override
	public int findBypdNumber(String purId, String tianJia, String csComment, String purSum, String purCount,String braId,SnUser user) {
		//通过业务id删除退货详情表
		scpm.deleteSalesDetail(purId);
		//通过业务id删除退货表
		scpm.deleteSales(purId);
		//id																					time
		String time = Tools.getDateOrderNo();
		//按&拆分tianjia																			a
		String[] a = tianJia.split("&");
		//查询采购商品详情表																			fdbp
		List<SnComPurDetail> list = scpdm.findDetailBypurId(purId);
		//定义个变量
		int rows2 = 0;
		//定义变量数量
		Integer d = 0;
		//定义变量小计（小数类型）
		Double e = 0.00 ;
		//定义变量总数量
		Integer g = 0;
		//循环数组a
		for(int i=0;i<a.length;i++) {
			//按,拆分a																			b
			String[] b = a[i].split(",");
			//判断数组为0的退货数量是否为空
			if(!"".equals(b[0])) {
				//为空的话赋值为零   赋值给总数量
				g+=Integer.valueOf(b[0]);
			}
		}
		//如果g的总数量值为零时，返回2
		if(g.equals(0)) {
			return 2;
		}
		
		
		//得到退货对象
		SnComSales scs = new SnComSales();
		//退货id
		scs.setCsId(time);
		//分公司（参数）
		scs.setBraId(braId);
		//退货状态0
		scs.setCsState(0);
		//是否有效1
		scs.setIsva(1);
		//退货时间
		scs.setOptime(Tools.getTimeStr(new Date()));
		//退货人
		scs.setOper(user.getUserName());
		//退货备注
		scs.setCsComment(csComment);
		//业务id
		scs.setAllId(purId);
		//增加退货表
		scsm.insertSelective(scs);
		
		//循环数组a
		for(int i=0;i<a.length;i++) {
			//用b接收按,拆分的数组
			String[] b = a[i].split(",");
			//用aa接受按&拆分b[2]的数组
			String[] aa = b[2].split("&");
			//得到页面传来的数量赋值给总数量
			d+=Integer.valueOf(b[0].replace(",", ""));
			//得到页面上的小计赋值给总价格
			e+=Double.valueOf(b[0].replace(",", ""))*Double.valueOf(aa[0].replace("&", ""));
			//循环采购详情表
			for (SnComPurDetail snComPurDetail : list)  {
				String c = b[1].replace(",", "");
				//判断采购明细的商品id是否跟传过来的商品id一样
				if(c.equals(snComPurDetail.getComId())) {
					//得到采购详情表对象
					SnComPurDetail scpd = new SnComPurDetail();
					//采购详情表赋值
					scpd.setPdNumber(snComPurDetail.getPdNumber()-Integer.valueOf(b[0]));
					//采购详情商品id
					scpd.setComId(snComPurDetail.getComId());
					//采购详情表的采购id
					scpd.setPurId(purId);
					//得到总金额
					Double f = snComPurDetail.getPdSum().doubleValue()-(Double.valueOf(b[0].replace(",", ""))*Double.valueOf(b[2].replace("&", "")));
					//采购详情的金额
					scpd.setPdSum(BigDecimal.valueOf(f));
					//修改采购详情表
					scpdm.findBypdNumber(scpd);
				}
			}
			//判断数量是否为零或空
			if(!b[0].equals("0") && !b[0].equals("")) {
				//得到退货详情表对象
				SnComSaDetail scsd = new SnComSaDetail();
				//退货详情id
				scsd.setSdId(Tools.getDateOrderNo());
				//商品退货id
				scsd.setCsId(time);
				//商品退货数量
				scsd.setSdCount(Integer.valueOf(b[0].replace(",", "")));
				//已退货数量
				scsd.setSdAlready(0);
				//把退货详情表的操作人改为商品id
				scsd.setOper(b[1].replace(",", ""));
				//增加与退货详情表
				rows2 = scsdm.insertSelective(scsd);
			}
		}
		//得到采购表对象
		SnComPurchase scp = new SnComPurchase();
		//采购表id
		scp.setPurId(purId);
		//采购金额
		scp.setPurSum(BigDecimal.valueOf(Double.valueOf(purSum)-e));
		//采购数量
		scp.setPurCount(Integer.valueOf(purCount)-d);
		//给isva赋值
		scp.setIsva(21);
		//修改采购表 
		scpm.updateByPrimaryKeySelective(scp);
		
		if(rows2>0) {
			return 1;
		}else {
			return 0;
		}
	}

	/**
	 * 通过商品id和采购id查询采购详情表
	 */
	@Override
	public SnComPurDetail findByIdBianJi(SnComPurDetail scpd) {
		return scpdm.findByIdBianJi(scpd);
	}

	/**
	 * 通过退货的业务id查询退货详情表
	 */

	@Override
	public List<SnComSaDetail> findAllComSaDetail(Map<String, Object> map1) {
		return scsdm.findAllComSaDetail(map1);
	}

	/**
	 * 查询退货表数据
	 */
	@Override
	public List<SnComSaDetail> findAllSnComSales(Map<String, Object> map1) {
		return scsm.findAllSnComSales(map1);
	}

	/**
	 * 查询退货表行数
	 */
	@Override
	public int findAllComSaDetailCount(Map<String, Object> map1) {
		return scsm.findAllComSaDetailCount(map1);
	}
}


